import cloudbaseSDK from '@cloudbase/js-sdk';

// 环境ID常量
const DEFAULT_ENV_ID = 'yuegu-monopy-777-5fmwgrd03af5f19';

// 初始化 CloudBase
const app = cloudbaseSDK.init({
  env: import.meta.env.VITE_CLOUDBASE_ENV_ID || DEFAULT_ENV_ID
});

// 输出环境ID，用于调试
console.log('CloudBase 环境ID:', app.config.env);

// 获取登录状态
const auth = app.auth();

/**
 * 云开发工具类
 */
export const cloudbase = {
  /**
   * 获取云开发实例
   * @returns {Object} 云开发实例
   */
  getApp() {
    return app;
  },

  /**
   * 获取认证对象
   * @returns {Object} 认证对象
   */
  getAuth() {
    return auth;
  },

  /**
   * 获取数据库实例
   * @returns {Object} 数据库实例
   */
  getDatabase() {
    return app.database();
  },

  /**
   * 获取存储实例
   * @returns {Object} 存储实例
   */
  getStorage() {
    return app.storage();
  },

  /**
   * 调用云函数
   * @param {Object} options 调用参数
   * @param {String} options.name 云函数名称
   * @param {Object} options.data 云函数参数
   * @returns {Promise} 云函数执行结果
   */
  async callFunction(options) {
    try {
      const result = await app.callFunction({
        name: options.name,
        data: options.data
      });
      
      // 处理返回结果
      if (result.result) {
        return result.result;
      }
      
      return result;
    } catch (error) {
      console.error(`调用云函数 ${options.name} 失败:`, error);
      throw error;
    }
  },

  /**
   * 匿名登录
   * @returns {Promise} 登录结果
   */
  async anonymousLogin() {
    try {
      const loginState = await auth.getLoginState();
      if (loginState) {
        return loginState;
      }
      
      return await auth.signInAnonymously();
    } catch (error) {
      console.error('匿名登录失败:', error);
      throw error;
    }
  },

  /**
   * 检查登录状态
   * @returns {Promise<Boolean>} 是否已登录
   */
  async checkLoginStatus() {
    try {
      const loginState = await auth.getLoginState();
      return !!loginState;
    } catch (error) {
      console.error('检查登录状态失败:', error);
      return false;
    }
  },

  /**
   * 获取当前用户ID
   * @returns {Promise<String>} 用户ID
   */
  async getUserId() {
    try {
      // 优先从本地存储获取用户ID
      const storedUserId = localStorage.getItem('monopoly_user_id');
      if (storedUserId) {
        console.log('从本地存储获取到用户ID:', storedUserId);
        return storedUserId;
      }
      
      // 检查登录状态
      const loginState = await auth.getLoginState();
      
      // 如果未登录，尝试匿名登录
      if (!loginState) {
        console.log('未登录，尝试匿名登录');
        const loginResult = await this.anonymousLogin();
        if (loginResult && loginResult.user) {
          const userId = loginResult.user.uid;
          console.log('匿名登录成功，获取到用户ID:', userId);
          
          // 保存到本地存储
          localStorage.setItem('monopoly_user_id', userId);
          return userId;
        }
      } else {
        // 已登录，获取用户ID
        const userId = loginState.user ? loginState.user.uid : null;
        console.log('已登录，获取到用户ID:', userId);
        
        // 保存到本地存储
        if (userId) {
          localStorage.setItem('monopoly_user_id', userId);
        }
        
        return userId;
      }
      
      return null;
    } catch (error) {
      console.error('获取用户ID失败:', error);
      return null;
    }
  }
};

/**
 * 检查云开发环境配置是否有效
 * @returns {Boolean} 环境配置是否有效
 */
export function checkEnvironment() {
  try {
    const config = app.config;
    
    // 检查环境ID是否有效
    if (!config.env) {
      console.warn('云开发环境ID未配置');
      return false;
    }
    
    return true;
  } catch (error) {
    console.error('检查环境配置失败:', error);
    return false;
  }
}


/**
 * 确保用户已登录，如果未登录则尝试匿名登录
 * @returns {Promise<Object>} 登录状态和用户信息
 */
export async function ensureLogin() {
  try {
    // 检查登录状态
    const isLoggedIn = await cloudbase.checkLoginStatus();
    
    // 如果未登录，尝试匿名登录
    if (!isLoggedIn) {
      console.log('未登录，尝试匿名登录');
      const result = await cloudbase.anonymousLogin();
      
      // 保存用户ID到本地存储
      if (result && result.user && result.user.uid) {
        localStorage.setItem('monopoly_user_id', result.user.uid);
      }
      
      return {
        isLoggedIn: true,
        user: result.user
      };
    }
    
    // 已登录，获取用户信息
    const auth = cloudbase.getAuth();
    const loginState = await auth.getLoginState();
    
    // 保存用户ID到本地存储
    if (loginState && loginState.user && loginState.user.uid) {
      localStorage.setItem('monopoly_user_id', loginState.user.uid);
    }
    
    return {
      isLoggedIn: true,
      user: loginState.user
    };
  } catch (error) {
    console.error('登录失败:', error);
    return {
      isLoggedIn: false,
      user: null
    };
  }
}

/**
 * 检查环境ID是否有效
 */
export const isValidEnvId = (() => {
  try {
    return !!app.config.env;
  } catch (error) {
    return false;
  }
})();

export default cloudbase;
